home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / plotting / contour / contour.lha / Contour / list.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-08-28  |  6.2 KB  |  304 lines
  1. /*** list.c - linked list procedures ***/
  2.  
  3. #include <stdio.h>
  4. #include <strings.h>
  5. #include <math.h>
  6. #include "contour.h"
  7.  
  8. /* initialize the list */
  9. initialize_list()
  10. {
  11.    extern triaptr tria_listhead, tria_listtail;
  12.    extern segmptr segm_listhead, segm_listtail;
  13.    extern plotptr plot_listhead, plot_listtail;
  14.  
  15.    tria_listhead = NULL;
  16.    tria_listtail = NULL;
  17.    segm_listhead = NULL;
  18.    segm_listtail = NULL;
  19.    plot_listhead = NULL;
  20.    plot_listtail = NULL;
  21. }
  22.  
  23. /* triangles are used to store surface information */
  24. triaptr make_tria(p1,p2,p3)
  25. data *p1,*p2,*p3;
  26. {
  27.    char *malloc();
  28.    triaptr newptr;
  29.  
  30.    if ((newptr = (triaptr)malloc(sizeof(tria)))!=NULL) {
  31.       newptr->pt1 = *p1;
  32.       newptr->pt2 = *p2;
  33.       newptr->pt3 = *p3;
  34.       newptr->next = NULL;
  35.       newptr->prev = NULL;
  36.    }
  37.    return(newptr);
  38. }
  39.  
  40. /* Insert a tria at the tail of the current triangle list */
  41. triaptr insert_tria(p1,p2,p3)
  42. data *p1,*p2,*p3;
  43. {
  44.    extern  triaptr tria_listhead, tria_listtail;
  45.    triaptr prev,next,A,B;
  46.    triaptr make_tria();
  47.  
  48.    A = tria_listtail;
  49.    if ((B=make_tria(p1,p2,p3))!=NULL) {
  50.       if (A==NULL) {
  51.          tria_listhead = B;
  52.          tria_listtail = B;
  53.       } else {
  54.          prev = A->prev;
  55.          next = A->next;
  56.          B->next = next;
  57.          B->prev = A;
  58.          A->next = B;
  59.          if (next    != NULL) next->prev = B;
  60.          if (B->next == NULL) tria_listtail = B;
  61.       }
  62.    }
  63.    return(B);
  64. }
  65.  
  66. void print_tria_list()
  67. {
  68.    void    print_point();
  69.    extern  triaptr tria_listhead, tria_listtail;
  70.    triaptr T;
  71.  
  72.    for (T=tria_listhead; T!=NULL; T=T->next) {
  73.       print_point(&(T->pt1));
  74.       print_point(&(T->pt2));
  75.       print_point(&(T->pt3));
  76.       fprintf(stdout,"\n");
  77.    }
  78. }
  79.  
  80. void print_point(pt)
  81. data *pt;
  82. {
  83.    fprintf(stdout,"x= %10.5f y= %10.5f z= %10.5f\n",pt->x,pt->y,pt->z);
  84. }
  85.  
  86. /* segments are used to store all the contours */
  87. segmptr make_segm(p1,p2)
  88. data *p1,*p2;
  89. {
  90.    char *malloc();
  91.    segmptr newptr;
  92.  
  93.    if ((newptr = (segmptr)malloc(sizeof(segm)))!=NULL) {
  94.       newptr->pt1 = *p1;
  95.       newptr->pt2 = *p2;
  96.       newptr->next = NULL;
  97.       newptr->prev = NULL;
  98.    }
  99.    return(newptr);
  100. }
  101.  
  102. /* Insert a segm at the tail of the current segment list */
  103. segmptr insert_segm(p1,p2)
  104. data *p1,*p2;
  105. {
  106.    extern  segmptr segm_listhead, segm_listtail;
  107.    segmptr prev,next,A,B;
  108.    segmptr make_segm();
  109.  
  110.    A = segm_listtail;
  111.    if ((B=make_segm(p1,p2))!=NULL) {
  112.       if (A==NULL) {
  113.          segm_listhead = B;
  114.          segm_listtail = B;
  115.       } else {
  116.          prev = A->prev;
  117.          next = A->next;
  118.          B->next = next;
  119.          B->prev = A;
  120.          A->next = B;
  121.          if (next != NULL) next->prev = B;
  122.          if (B->next == NULL) segm_listtail = B;
  123.       }
  124.    }
  125.    return(B);
  126. }
  127.  
  128. /* Delete segm at address L */
  129. void delete_segm(L)
  130. segmptr L;
  131. {
  132.    extern  segmptr segm_listhead, segm_listtail;
  133.    segmptr prev,next;
  134.  
  135.    prev = L->prev;
  136.    next = L->next;
  137.    if (prev!=NULL) prev->next = next;
  138.    if (next!=NULL) next->prev = prev;
  139.    if (L==segm_listhead) segm_listhead = next;
  140.    if (L==segm_listtail) segm_listtail = prev;
  141.    free ((char*)L);
  142.    L = NULL;
  143. }
  144.  
  145. void print_segm_list()
  146. {
  147.    void    print_point();
  148.    extern  segmptr segm_listhead, segm_listtail;
  149.    segmptr S;
  150.  
  151.    for (S=segm_listhead; S!=NULL; S=S->next) {
  152.       print_point(&(S->pt1));
  153.       print_point(&(S->pt2));
  154.       fprintf(stdout,"\n");
  155.    }
  156. }
  157.  
  158. /* nodes are used to store all the points of the separate contours */
  159. nodeptr make_node(p1)
  160. data *p1;
  161. {
  162.    char *malloc();
  163.    nodeptr newptr;
  164.  
  165.    if ((newptr = (nodeptr)malloc(sizeof(node)))!=NULL) {
  166.       newptr->pt   = *p1;
  167.       newptr->next = NULL;
  168.       newptr->prev = NULL;
  169.    }
  170.    return(newptr);
  171. }
  172.  
  173. /* Insert a node at the tail of the current plot-node list */
  174. nodeptr insert_tailnode(p1,L)
  175. data *p1;
  176. plotptr L;
  177. {
  178.    nodeptr prev,next,A,B;
  179.    nodeptr make_node();
  180.  
  181.    A = L->nodetail;
  182.    if ((B=make_node(p1))!=NULL) {
  183.       if (A==NULL) {
  184.          L->nodehead = B;
  185.          L->nodetail = B;
  186.       } else {
  187.          prev = A->prev;
  188.          next = A->next;
  189.          B->next = next;
  190.          B->prev = A;
  191.          A->next = B;
  192.          if (next    != NULL) next->prev = B;
  193.          if (B->next == NULL) L->nodetail = B;
  194.       }
  195.    }
  196.    return(B);
  197. }
  198.  
  199. /* Insert a node at the head of the current plot-node list */
  200. nodeptr insert_headnode(p1,L)
  201. data *p1;
  202. plotptr L;
  203. {
  204.    nodeptr prev,next,A,B;
  205.    nodeptr make_node();
  206.  
  207.    A = L->nodehead;
  208.    if ((B=make_node(p1))!=NULL) {
  209.       if (A==NULL) {
  210.          L->nodehead = B;
  211.          L->nodetail = B;
  212.       } else {
  213.          B->next = A;
  214.          A->prev = B;
  215.          L->nodehead = B;
  216.       }
  217.    }
  218.    return(B);
  219. }
  220.  
  221. /* Delete node on plot L at address A */
  222. void delete_node(A,L)
  223. nodeptr A;
  224. plotptr L;
  225. {
  226.    nodeptr prev,next;
  227.  
  228.    prev = A->prev;
  229.    next = A->next;
  230.    if (prev!=NULL) prev->next = next;
  231.    if (next!=NULL) next->prev = prev;
  232.    if (A==L->nodehead) L->nodehead = next;
  233.    if (A==L->nodetail) L->nodetail = prev;
  234.    free ((char*)A);
  235.    A = NULL;
  236. }
  237.  
  238. void print_node_list(L)
  239. plotptr L;
  240. {
  241.    void    print_point();
  242.    nodeptr N;
  243.  
  244.    for (N=L->nodehead; N!=NULL; N=N->next) 
  245.       print_point(&(N->pt));
  246.    fprintf(stdout,"\n");
  247. }
  248.  
  249. /* plots are used to store the nodes of each separate contour */
  250. plotptr make_plot(lvl)
  251. double  lvl;
  252. {
  253.    char *malloc();
  254.    plotptr newptr;
  255.  
  256.    if ((newptr = (plotptr)malloc(sizeof(plot)))!=NULL) {
  257.       newptr->level    = lvl;
  258.       newptr->nodehead = NULL;
  259.       newptr->nodetail = NULL;
  260.       newptr->next     = NULL;
  261.       newptr->prev     = NULL;
  262.    }
  263.    return(newptr);
  264. }
  265.  
  266. /* Insert a plot at the tail of the current plot list */
  267. plotptr insert_plot(lvl)
  268. double lvl;
  269. {
  270.    extern  plotptr plot_listhead, plot_listtail;
  271.    plotptr prev,next,A,B;
  272.    plotptr make_plot();
  273.  
  274.    A = plot_listtail;
  275.    if ((B=make_plot(lvl))!=NULL) {
  276.       if (A==NULL) {
  277.          plot_listhead = B;
  278.          plot_listtail = B;
  279.       } else {
  280.          prev = A->prev;
  281.          next = A->next;
  282.          B->next = next;
  283.          B->prev = A;
  284.          A->next = B;
  285.          if (next != NULL) next->prev = B;
  286.          if (B->next == NULL) plot_listtail = B;
  287.       }
  288.    }
  289.    return(B);
  290. }
  291.  
  292. /* print the plots */
  293. void print_plot_list()
  294. {
  295.    void    print_node_list();
  296.    extern  plotptr plot_listhead;
  297.    plotptr L;
  298.  
  299.    for (L=plot_listhead; L!=NULL; L=L->next) {
  300.       fprintf(stdout,"Level = %10.5f\n",L->level);
  301.       print_node_list(L);
  302.    }
  303. }
  304.